Pythondagi imkoniyatlarni ochish: Global dasturchilar uchun ilg'or `functools` dekoratorlari

Dasturiy ta'minotni ishlab chiqishning doimiy rivojlanayotgan landshaftida Python o'zining o'qilishi va keng kutubxonalari bilan mashhur bo'lgan dominant kuch bo'lib qolmoqda. Dunyo bo'ylab dasturchilar uchun uning ilg'or xususiyatlarini o'zlashtirish samarali, mustahkam va parvarish qilinadigan ilovalarni yaratish uchun juda muhimdir. Pythonning eng kuchli vositalaridan biri `functools` modulida joylashgan dekoratorlardir. Ushbu qo'llanma uchta muhim dekoratorni ko'rib chiqadi: `lru_cache` samaradorlikni optimallashtirish uchun, `singledispatch` moslashuvchan funksiya yuklash uchun va `wraps` funksiya metama'lumotlarini saqlash uchun. Ushbu dekoratorlarni tushunish va qo'llash orqali xalqaro Python dasturchilari o'zlarining kodlash amaliyotlarini va dasturiy ta'minotlarining sifatini sezilarli darajada yaxshilashlari mumkin.

Nima uchun `functools` dekoratorlari global auditoriya uchun muhim?

`functools` moduli yuqori tartibli funksiyalar va chaqiriladigan ob'ektlarni ishlab chiqishni qo'llab-quvvatlash uchun mo'ljallangan. Python 3.0 da joriy qilingan sintaktik shakar bo'lgan dekoratorlar, funksiyalar va usullarni toza va o'qiladigan tarzda o'zgartirish yoki yaxshilash imkonini beradi. Global auditoriya uchun bu bir qancha asosiy afzalliklarga olib keladi:

• Universallik: Pythonning sintaksisi va asosiy kutubxonalari standartlashtirilgan, bu dekoratorlar kabi tushunchalarni geografik joylashuvdan yoki dasturlash tajribasidan qat'i nazar, universal tushunarli qiladi.
• Samaradorlik: `lru_cache` hisoblash jihatidan qimmat funksiyalar samaradorligini sezilarli darajada oshirishi mumkin, bu turli mintaqalarda potentsial o'zgaruvchan tarmoq kechikishlari yoki resurs cheklovlari bilan ishlashda muhim omil hisoblanadi.
• Moslashuvchanlik: `singledispatch` turli xil ma'lumot turlariga moslasha oladigan kodni ta'minlaydi, bu turli xil ma'lumot formatlariga ega foydalanuvchi bazalariga xizmat ko'rsatadigan ilovalar uchun muhim bo'lgan umumiy va moslashuvchan kod bazasini targ'ib qiladi.
• Parvarish qilinishi: `wraps` dekoratorlar asl funksiyaning o'ziga xosligini buzmasligini ta'minlaydi, bu xalqaro hamkorlikdagi dasturchilar jamoalari uchun muhim bo'lgan diskretifikatsiya va tekshiruvga yordam beradi.

Keling, ushbu dekoratorlarning har birini batafsil ko'rib chiqaylik.

1. `functools.lru_cache`: Samaradorlikni optimallashtirish uchun memoizatsiya

Dasturlashdagi eng keng tarqalgan samaradorlik tugunlaridan biri takroriy hisoblashlardan kelib chiqadi. Agar funksiya bir xil argumentlar bilan bir necha bor chaqirilsa va uning ijrosi qimmat bo'lsa, har safar natijani qayta hisoblash behuda ketadi. Aynan shu yerda memoizatsiya, ya'ni qimmat funksiya chaqiruvlari natijalarini keshga saqlash va bir xil kirishlar paydo bo'lganda keshlangan natijani qaytarish texnikasi bebaho bo'lib qoladi. Pythonning `functools.lru_cache` dekoratori buning uchun oqlangan yechimni taqdim etadi.

`lru_cache` nima?

`lru_cache` Eng Kam Ishlatilgan keshni bildiradi. Bu funksiyani o'rab turgan dekoratordir, uning natijalarini lug'atda saqlaydi. Dekoratsiyalangan funksiya chaqirilganda, `lru_cache` avval berilgan argumentlar uchun natija allaqachon keshda mavjudligini tekshiradi. Agar mavjud bo'lsa, keshlangan natija darhol qaytariladi. Aks holda, funksiya ishga tushiriladi, uning natijasi keshda saqlanadi va keyin qaytariladi. "Eng Kam Ishlatilgan" degani shuki, agar kesh maksimal hajmga yetsa, yangi yozuvlar uchun joy ajratish maqsadida eng kam ishlatilgan element tashlab yuboriladi.

Asosiy foydalanish va parametrlar

`lru_cache` dan foydalanish uchun uni shunchaki import qiling va uni funksiyangizga dekorator sifatida qo'llang:

            from functools import lru_cache

@lru_cache(maxsize=128)
def expensive_computation(x, y):
    """Qimmat hisoblashni simulyatsiya qiluvchi funksiya."""
    print(f"{x}, {y} uchun qimmat hisoblash amalga oshirilmoqda...")
    # Qandaydir og'ir ishni simulyatsiya qiling, masalan, tarmoq so'rovi, murakkab matematika
    return x * y + x / 2

            

              
                Copy
              
            
          

`maxsize` parametri saqlanishi kerak bo'lgan natijalar sonini boshqaradi. Agar `maxsize` `None` ga o'rnatilgan bo'lsa, kesh cheksiz o'sishi mumkin. Agar u ijobiy butun songa o'rnatilgan bo'lsa, u kesh hajmiga ishora qiladi. Kesh to'lganda, u eng kam ishlatilgan yozuvlarni tashlab yuboradi. `maxsize` uchun standart qiymat 128.

Asosiy mulohazalar va ilg'or foydalanish

• Hashlanadigan argumentlar: Keshlanadigan funksiyaga berilgan argumentlar hashlanadigan bo'lishi kerak. Bu raqamlar, satrlar, to'plamlar (hashlanadigan elementlardan iborat) va frozensetlar kabi o'zgarmas turlari qabul qilinishini bildiradi. Listlar, lug'atlar va setlar kabi o'zgaruvchan turlar emas.
• `typed=True` parametri: Standart holatda, `lru_cache` teng bo'lgan turli xil turlarning argumentlarini bir xil deb hisoblaydi. Masalan, `cached_func(3)` va `cached_func(3.0)` bir xil kesh yozuviga tegishi mumkin. `typed=True` ni o'rnatish keshni argument turlariga sezgir qiladi. Shunday qilib, `cached_func(3)` va `cached_func(3.0)` alohida keshlanadi. Bu funksiya ichida turga xos mantiq mavjud bo'lsa foydali bo'lishi mumkin.
• Keshni bekor qilish: `lru_cache` keshni boshqarish uchun usullarni taqdim etadi. `cache_info()` kesh zarbalari, o'tkazib yuborishlar, joriy hajmi va maksimal hajmi haqida statistika bilan nomlangan to'plamni qaytaradi. `cache_clear()` butun keshni tozalaydi.

            @lru_cache(maxsize=32)
def fibonacci(n):
    if n < 2:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

print(fibonacci(10))
print(fibonacci.cache_info())
fibonacci.cache_clear()
print(fibonacci.cache_info())

            

              
                Copy
              
            
          

`lru_cache` global qo'llanilishi

Ilova real vaqtda valyuta kurslarini taqdim etadigan stsenariyni ko'rib chiqing. Ushbu kurslarni tashqi API dan olish sekin bo'lishi va resurslarni iste'mol qilishi mumkin. `lru_cache` ushbu kurslarni oladigan funksiyaga qo'llanilishi mumkin:

            import requests
from functools import lru_cache

@lru_cache(maxsize=10)
def get_exchange_rate(base_currency, target_currency):
    """Tashqi API dan eng so'nggi valyuta kursini oladi."""
    # Haqiqiy dunyo ilovasida API kalitlari, xatoliklarni boshqarish va hokazolarni bajaring.
    api_url = f"https://api.example.com/rates?base={base_currency}&target={target_currency}"
    try:
        response = requests.get(api_url, timeout=5) # Vaqtni belgilash
        response.raise_for_status() # Yomon javoblar (4xx yoki 5xx) uchun HTTPError ni chiqaradi
        data = response.json()
        return data['rate']
    except requests.exceptions.RequestException as e:
        print(f"Valyuta kursini olishda xatolik: {e}")
        return None

# Yevropadagi foydalanuvchi EUR dan USD ga kursni so'raydi
europe_user_rate = get_exchange_rate('EUR', 'USD')
print(f"EUR dan USD ga: {europe_user_rate}")

# Osiyodagi foydalanuvchi EUR dan USD ga kursni so'raydi
# Agar maxsize ichida bo'lsa, bu keshni uradi
asian_user_rate = get_exchange_rate('EUR', 'USD') 
print(f"EUR dan USD ga (keshlangan): {asian_user_rate}")

# Amerikadagi foydalanuvchi USD dan EUR ga kursni so'raydi
americas_user_rate = get_exchange_rate('USD', 'EUR')
print(f"USD dan EUR ga: {americas_user_rate}")

            

              
                Copy
              
            
          

Ushbu misolda, agar bir nechta foydalanuvchi qisqa vaqt ichida bir xil valyuta juftligini so'ragan bo'lsa, qimmat API chaqiruvi faqat bir marta amalga oshiriladi. Bu, ayniqsa, global foydalanuvchi bazasiga ega xizmatlar uchun o'xshash ma'lumotlarga kirishda, server yukini kamaytirish va barcha foydalanuvchilar uchun javob vaqtlarini yaxshilashda foydalidir.

2. `functools.singledispatch`: Generik funksiyalar va polimorfizm

Ko'pgina dasturlash paradigmalari, polimorfizm turli xil turlarga ega ob'ektlarga umumiy superklass turlariga ega ob'ektlar sifatida muomala qilish imkonini beradi. Python'da bu ko'pincha duck typing orqali amalga oshiriladi. Biroq, birinchi argumentining o'ziga xos turiga asoslangan holda xatti-harakatlarni aniqlashni istagan holatlar uchun, `singledispatch` tur asosidagi diskretifikatsiyaga ega generik funksiyalarni yaratish uchun kuchli mexanizmni taklif etadi. U funksiya uchun standartli amalni aniqlash va turli argument turlari uchun maxsus amalni ro'yxatdan o'tkazish imkonini beradi.

`singledispatch` nima?

`singledispatch` generik funksiyalarni ta'minlaydigan funksiya dekoratordir. Generik funksiya - bu birinchi argumentining turiga qarab har xil harakat qiladigan funksiya. Siz `@singledispatch` bilan bezatilgan asosiy funksiyani aniqlaysiz va keyin turli turlar uchun maxsus amalni ro'yxatdan o'tkazish uchun `@base_function.register(Type)` dekoratoridan foydalanasiz.

Asosiy foydalanish

Turli xil chiqish formatlari uchun ma'lumotlarni formatlash misolida ko'rib chiqaylik:

            from functools import singledispatch

@singledispatch
def format_data(data):
    """Standart amal: ma'lumotlarni satr sifatida formatlaydi."""
    return str(data)

@format_data.register(int)
def _(data):
    """Butun sonlarni minglik ajratgich bilan formatlaydi."""
    return "{:,.0f}".format(data)

@format_data.register(float)
def _(data):
    """O'nlik sonlarni ikkita o'nlik vergul bilan formatlaydi."""
    return "{:.2f}".format(data)

@format_data.register(list)
def _(data):
    """Listlarni elementlarni "|" bilan biriktirish orqali formatlaydi."""
    return " | ".join(map(str, data))

            

              
                Copy
              
            
          

Ro'yxatga olingan amallar uchun funksiya nomi sifatida `_` dan foydalanishga e'tibor bering. Bu umumiy konvensiya hisoblanadi, chunki ro'yxatga olingan funksiyaning nomi muhim emas; faqat uning turi generik funksiyaga berilgan birinchi argumentning turi uchun muhimdir.

Diskretifikatsiya qanday ishlaydi?

`format_data(some_value)` chaqirilganda:

1. Python `some_value` ning turini tekshiradi.
2. Agar ma'lum bir tur uchun ro'yxatdan o'tish mavjud bo'lsa (masalan, `int`, `float`, `list`), tegishli ro'yxatga olingan funksiya chaqiriladi.
3. Agar maxsus ro'yxatdan o'tish topilmasa, `@singledispatch` bilan bezatilgan asl funksiya (standart amal) chaqiriladi.
4. `singledispatch` merosni ham boshqaradi. Agar `Subclass` turi `BaseClass` dan meros olinsa va `format_data` `BaseClass` uchun ro'yxatdan o'tishga ega bo'lsa, agar `Subclass` uchun maxsus ro'yxatdan o'tish mavjud bo'lmasa, `Subclass` misoli bilan `format_data` ni chaqirish `BaseClass` amalidan foydalanadi.

`singledispatch` global qo'llanilishi

Xalqaro ma'lumotlarni qayta ishlovchi xizmatni tasavvur qiling. Foydalanuvchilar turli formatlarda ma'lumotlarni yuborishlari mumkin (masalan, raqamli qiymatlar, geografik koordinatalar, vaqt belgilari, elementlar ro'yxati). Ushbu ma'lumotlarni qayta ishlaydigan va standartlashtiradigan funksiya `singledispatch` dan katta foyda ko'rishi mumkin.

            from functools import singledispatch
from datetime import datetime

@singledispatch
def process_input(value):
    """Standart ishlov berish: noma'lum turlarni yozib oladi."""
    print(f"Noma'lum kirish turi yozib olindi: {type(value).__name__} - {value}")
    return None

@process_input.register(str)
def _(value):
    """Satrlarni ishlaydi, ular sanalar yoki oddiy matn bo'lishi mumkin."""
    try:
        # ISO formatidagi sanani parslashga urinib ko'ring
        return datetime.fromisoformat(value.replace('Z', '+00:00'))
    except ValueError:
        # Agar sana bo'lmasa, shunday qoldiring (yoki boshqa matnni qayta ishlashni bajaring)
        return value.strip()

@process_input.register(int)
def _(value):
    """Butun sonlarni ishlaydi, ular haqiqiy mahsulot identifikatorlari deb taxmin qilinadi."""
    if value < 100000: # Misol uchun, o'zboshimchalik bilan tekshirish
        print(f"Ogohlantirish: Potentsial noto'g'ri mahsulot identifikatori: {value}")
    return f"PID-{value:06d}" # PID-000001 sifatida formatlaydi

@process_input.register(tuple)
def _(value):
    """To'plamlarni ishlaydi, ular geografik koordinatalar (lat, lon) deb taxmin qilinadi."""
    if len(value) == 2 and all(isinstance(coord, (int, float)) for coord in value):
        return {'latitude': value[0], 'longitude': value[1]}
    else:
        print(f"Ogohlantirish: Noto'g'ri koordinata to'plami formati: {value}")
        return None

# --- Global auditoriya uchun misol --- 

# Yaponiyadagi foydalanuvchi vaqt belgisini yuboradi
input1 = "2023-10-27T10:00:00Z"
processed1 = process_input(input1)
print(f"Kirish: {input1}, Ishlangan: {processed1}")

# AQShdagi foydalanuvchi mahsulot identifikatorini yuboradi
input2 = 12345
processed2 = process_input(input2)
print(f"Kirish: {input2}, Ishlangan: {processed2}")

# Braziliyadagi foydalanuvchi geografik koordinatalarni yuboradi
input3 = ( -23.5505, -46.6333 )
processed3 = process_input(input3)
print(f"Kirish: {input3}, Ishlangan: {processed3}")

# Avstraliyadagi foydalanuvchi oddiy matnni yuboradi
input4 = "Sydney Office"
processed4 = process_input(input4)
print(f"Kirish: {input4}, Ishlangan: {processed4}")

# Boshqa tur
input5 = [1, 2, 3]
processed5 = process_input(input5)
print(f"Kirish: {input5}, Ishlangan: {processed5}")

            

              
                Copy
              
            
          

`singledispatch` dasturchilarga aniq tur tekshiruvlariga (`if isinstance(...)`) ehtiyoj sezmasdan, turli xil kirish turlarini yaxshi boshqaradigan kutubxonalarni yoki funksiyalarni yaratishga imkon beradi. Bu kodni yanada toza va kengaytiriladigan qiladi, bu esa xalqaro loyihalarda ma'lumotlar formatlari juda farq qilishi mumkin bo'lgan joylarda juda foydalidir.

3. `functools.wraps`: Funksiya metama'lumotlarini saqlash

Dekoratorlar mavjud funksiyalarni ularning asl kodini o'zgartirmasdan qo'shimcha funksionallik qo'shish uchun kuchli vositadir. Biroq, dekoratordan foydalanishning yon ta'siri shundaki, asl funksiyaning metama'lumotlari (masalan, uning nomi, hujjatlari va annotatsiyalari) dekoratorning wrapper funksiyasining metama'lumotlari bilan almashtiriladi. Bu tekshiruv vositalari, diskretifikatorlar va hujjat yaratuvchilari uchun muammolarga olib kelishi mumkin. `functools.wraps` bu muammoni hal qiladigan dekoratordir.

`wraps` nima?

`wraps` - bu sizning maxsus dekoratoringiz ichidagi wrapper funksiyasiga qo'llaniladigan dekoratordir. U asl funksiyaning metama'lumotlarini wrapper funksiyasiga nusxalaydi. Bu shuni anglatadiki, sizning dekoratordan foydalangandan so'ng, dekoratsiyalangan funksiya tashqi dunyoga asl funksiya kabi ko'rinadi, uning nomi, hujjatlari va boshqa atributlarini saqlab qoladi.

Asosiy foydalanish

Oddiy loglash dekoratorini yarataylik va `wraps` bilan va `wraps` siz uning effektini ko'rib chiqaylik.

`wraps` siz

            def simple_logging_decorator(func):
    def wrapper(*args, **kwargs):
        print(f"Funksiya chaqirilmoqda: {func.__name__}")
        result = func(*args, **kwargs)
        print(f"Funksiya tugallandi: {func.__name__}")
        return result
    return wrapper

@simple_logging_decorator
def greet(name):
    """Bir kishini salomlaydi."""
    return f"Salom, {name}!"

print(f"Funksiya nomi: {greet.__name__}")
print(f"Funksiya hujjatlari: {greet.__doc__}")
print(greet("World"))

            

              
                Copy
              
            
          

Agar siz buni ishga tushirsangiz, siz `greet.__name__` 'wrapper' ekanligini va `greet.__doc__` `None` ekanligini ko'rasiz, chunki `wrapper` funksiyasining metama'lumotlari `greet` ning metama'lumotlarini almashtirgan.

`wraps` bilan

Endi `wraps` ni `wrapper` funksiyasiga qo'llaylik:

            from functools import wraps

def robust_logging_decorator(func):
    @wraps(func) # wraps ni wrapper funksiyasiga qo'llang
    def wrapper(*args, **kwargs):
        print(f"Funksiya chaqirilmoqda: {func.__name__}")
        result = func(*args, **kwargs)
        print(f"Funksiya tugallandi: {func.__name__}")
        return result
    return wrapper

@robust_logging_decorator
def greet_properly(name):
    """Bir kishini salomlaydi (to'g'ri bezatilgan)."""
    return f"Salom, {name}!"

print(f"Funksiya nomi: {greet_properly.__name__}")
print(f"Funksiya hujjatlari: {greet_properly.__doc__}")
print(greet_properly("World Again"))

            

              
                Copy
              
            
          

Bu ikkinchi misolni ishga tushirish quyidagilarni ko'rsatadi:

            Funksiya nomi: greet_properly
Funksiya hujjatlari: Bir kishini salomlaydi (to'g'ri bezatilgan).
Funksiya chaqirilmoqda: greet_properly
Funksiya tugallandi: greet_properly
Salom, World Again!

            

              
                Copy
              
            
          

`__name__` to'g'ri 'greet_properly' ga o'rnatilgan va `__doc__` satri saqlanib qolgan. `wraps` shuningdek, `__module__`, `__qualname__` va `__annotations__` kabi boshqa tegishli atributlarni ham nusxalaydi.

`wraps` global qo'llanilishi

Hamkorlikdagi xalqaro dasturlash muhitlarida aniq va qulay kod juda muhimdir. Jamoa a'zolari turli vaqt zonalari bo'lganida yoki kod bazasini bilish darajasi har xil bo'lganida diskretifikatsiya yanada qiyinlashishi mumkin. `wraps` bilan funksiya metama'lumotlarini saqlash kodni tozaligini saqlashga va diskretifikatsiya va hujjatlashtirishga yordam beradi.

Masalan, veb-API nuqtasi handlerini ishga tushirishdan oldin autentifikatsiya tekshiruvlarini qo'shadigan dekoratordagi holatni ko'rib chiqing. `wraps` siz, nuqtadagi nom va hujjatlari yo'qolishi mumkin, bu boshqa dasturchilar (yoki avtomatlashtirilgan vositalar) nuqta nima qilishini tushunishini yoki muammolarni diskretifikatsiya qilishini qiyinlashtiradi. `wraps` dan foydalanish nuqtadagi o'ziga xoslik aniq qolishini ta'minlaydi.

            from functools import wraps

def require_admin_role(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        # Haqiqiy ilovada, bu sessiya/token dan foydalanuvchi rollarini tekshiradi
        is_admin = kwargs.get('user_role') == 'admin'
        if not is_admin:
            raise PermissionError("Admin roli talab qilinadi")
        return func(*args, **kwargs)
    return wrapper

@require_admin_role
def delete_user(user_id, user_role=None):
    """Foydalanuvchini tizimdan o'chiradi. Admin imtiyozlari talab qilinadi."""
    print(f"Foydalanuvchi {user_id} o'chirilmoqda...")
    # Haqiqiy o'chirish mantiq
    return True

# --- Misol --- 

# Admin foydalanuvchisidan so'rovni simulyatsiya qilish
try:
    delete_user(101, user_role='admin')
except PermissionError as e:
    print(e)

# Oddiy foydalanuvchidan so'rovni simulyatsiya qilish
try:
    delete_user(102, user_role='user')
except PermissionError as e:
    print(e)

# Dekoratsiyalangan funksiyani tekshirish
print(f"Funksiya nomi: {delete_user.__name__}")
print(f"Funksiya hujjatlari: {delete_user.__doc__}")

# Eslatma: agar asl funksiyada mavjud bo'lsa, __annotations__ ham saqlanadi.

            

              
                Copy
              
            
          

`wraps` o'zini yaxshi tutadigan dekoratorlarni qurayotgan yoki kengroq foydalanish uchun mo'ljallangan kutubxonalarni ishlab chiqayotgan har bir kishi uchun ajralmas vositadir. Uning kengaytirilgan funksiyalari metama'lumotlar bo'yicha bashorat qilinadigan tarzda harakat qilishini ta'minlaydi, bu global dasturiy loyihalarda parvarishlash va hamkorlik uchun juda muhimdir.

Dekoratorlarni birlashtirish: Kuchli sinergiya

`functools` dekoratorlarining haqiqiy kuchi ko'pincha ular birgalikda ishlatilganda yuzaga chiqadi. `lru_cache` dan foydalanib biror funksiyani optimallashtirishni, `singledispatch` bilan polimorfik harakat qilishni va `wraps` bilan metama'lumotlar saqlanishini ta'minlashni istagan stsenariyni ko'rib chiqaylik.

`singledispatch` dekoratsiyalangan funksiyaning diskretifikatsiya uchun asos bo'lishini talab qiladi va `lru_cache` har qanday funksiyaning ijrosini optimallashtiradi, ular birgalikda ishlashlari mumkin. Biroq, `wraps` odatda metama'lumotlarni saqlash uchun maxsus dekorator ichida qo'llaniladi. `lru_cache` va `singledispatch` odatda funksiyalarga yoki `singledispatch` holatida asosiy funksiyaga qo'llaniladi.

Maxsus dekorator ichida `lru_cache` va `wraps` dan foydalanish ko'proq tarqalgan:

            from functools import lru_cache, wraps

def cached_and_logged(maxsize=128):
    def decorator(func):
        @wraps(func)
        @lru_cache(maxsize=maxsize)
        def wrapper(*args, **kwargs):
            # Eslatma: lru_cache ichida loglash qiyin bo'lishi mumkin,
            # chunki u faqat kesh o'tkazib yuborilganda ishlaydi. Doimiy loglash uchun,
            # ko'pincha kesh qismidan tashqarida loglash yoki cache_info ga tayanib
            # ishlash yaxshiroqdir.
            print(f"(Kesh o'tkazib yuborildi/ishladi) Ijro etilmoqda: {func.__name__} argumentlar bilan {args}, kwargs {kwargs}")
            return func(*args, **kwargs)
        return wrapper
    return decorator

@cached_and_logged(maxsize=4)
def complex_calculation(a, b):
    """Simulyatsiya qilingan murakkab hisoblashni bajaradi."""
    print(f"  - Hisoblash bajarilmoqda {a}+{b} uchun...")
    return a + b * 2

print(f"1-chaqiruv: {complex_calculation(1, 2)}") # Kesh o'tkazib yuborildi
print(f"2-chaqiruv: {complex_calculation(1, 2)}") # Kesh zarbasi
print(f"3-chaqiruv: {complex_calculation(3, 4)}") # Kesh o'tkazib yuborildi
print(f"4-chaqiruv: {complex_calculation(1, 2)}") # Kesh zarbasi
print(f"5-chaqiruv: {complex_calculation(5, 6)}") # Kesh o'tkazib yuborildi, (1,2) yoki (3,4) ni chiqarib yuborishi mumkin

print(f"Funksiya nomi: {complex_calculation.__name__}")
print(f"Funksiya hujjatlari: {complex_calculation.__doc__}")
print(f"Kesh haqida ma'lumot: {complex_calculation.cache_info()}")

            

              
                Copy
              
            
          

Ushbu birlashtirilgan dekoratorda, `@wraps(func)` `complex_calculation` metama'lumotlari saqlanishini ta'minlaydi. `@lru_cache` dekoratori haqiqiy hisoblashni optimallashtiradi va `wrapper` ichidagi chop etish buyrug'i faqat kesh o'tkazib yuborilganda ishga tushadi, bu asosiy funksiyaning qachon haqiqatdan ham chaqirilganligi haqida ma'lumot beradi. `maxsize` parametri `cached_and_logged` factory funksiyasi orqali sozlanishi mumkin.

Xulosa: Global Python dasturlashni kuchaytirish

`functools` moduli, `lru_cache`, `singledispatch` va `wraps` kabi dekoratorlar bilan Python dasturchilariga butun dunyo bo'ylab murakkab vositalarni taqdim etadi. Ushbu dekoratorlar dasturiy ta'minotni ishlab chiqishdagi keng tarqalgan muammolarni, samaradorlikni optimallashtirish va turli xil ma'lumot turlarini boshqarishdan tortib, kodning yaxlitligi va dasturchi unumdorligini saqlashgacha hal qiladi.

• `lru_cache` sizga funksiya natijalarini aqlli kesh orqali ilovalarni tezlashtirish imkonini beradi, bu samaradorlikka sezgir global xizmatlar uchun muhimdir.
• `singledispatch` moslashuvchan va kengaytiriladigan generik funksiyalarni yaratishga imkon beradi, bu kodni xalqaro kontekstlarda uchrashi mumkin bo'lgan keng ko'lamli ma'lumot formatlariga moslashuvchan qiladi.
• `wraps` yaxshi ishlaydigan dekoratorlarni qurish uchun muhimdir, bu sizning kengaytirilgan funksiyalaringiz shaffof va parvarish qilinadigan bo'lib qolishini ta'minlaydi, bu hamkorlikdagi va global tarqatilgan dasturiy jamoalar uchun juda muhimdir.

Ushbu ilg'or `functools` xususiyatlarini Python dasturlash jarayoniga birlashtirish orqali siz yanada samarali, mustahkam va tushunarli dasturiy ta'minotni yaratishingiz mumkin. Python global dasturchilar uchun tanlov tili sifatida davom etar ekan, ushbu kuchli dekoratorlarni chuqur tushunish sizga raqobatbardosh ustunlikni taqdim etadi.

Ushbu vositalarni o'zlashtiring, ularni loyihalaringizda sinab ko'ring va global ilovalaringiz uchun Pythonic nafosat va samaradorlikning yangi darajalarini oching.